home *** CD-ROM | disk | FTP | other *** search
/ BMUG Revelations / BMUG Revelations.toast / Utilities / System Utility / Parrot / source / Parrot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-18  |  19.8 KB  |  829 lines  |  [TEXT/KAHL]
  1. /**********
  2.  * Sound Confusion
  3.  *
  4.  *        Copyright © 1992 Bernie Bernstein
  5.  *        9/11/92 - 10/14/92
  6.  ***********/
  7.  
  8.  
  9. #include    <GestaltEqu.h>
  10. #include    <Memory.h>
  11. #include    <OSEvents.h>
  12. #include    <Sound.h>
  13. #include    <SoundInput.h>
  14. #include    <StdIO.h>
  15. #include    <Types.h>
  16.  
  17. #include "Parrot.h"
  18.  
  19. /* how much memory should the program reserve after making the buffers? */
  20. #define kExtraMem        0x5000
  21.  
  22. /* reset the channels every kResetInterval seconds */
  23. #define kResetInterval    30
  24.  
  25.  
  26. /*The HeaderSize constant is used to skip 20 bytes of the buffer when calling bufferCmd.
  27. The first 20 byte of the sound header need to be skipped so that the bufferCmd will be
  28. pointing at a SoundHeader Record and not an 'snd ' resource header. */
  29. #define kHeaderSize        20
  30.  
  31. typedef struct {
  32.     short        OnOff;
  33.     short         Level;
  34.     short         Length;
  35. } Level;
  36.  
  37.  
  38. Boolean    inStereo;
  39. short gThreshold;
  40. long gBuffSize;
  41. SCGlobals *globs;
  42. BufInfo gExtraBuffer;
  43. Boolean gPlayNRecord;
  44.  
  45.  
  46. /***
  47.  * BufPlay
  48.  *        This routine takes an snd buffer and a sound channel and turns the information
  49.  *        into a bufferCmd to the channel.
  50.  ***/
  51. void BufPlay (Handle Buf, SndChannelPtr    channel)
  52. {
  53.     SndCommand        localSndCmd;
  54.     OSErr            err;
  55.     
  56.     localSndCmd.cmd = bufferCmd;
  57.     localSndCmd.param1 = 0;
  58.     localSndCmd.param2 = (long) ((*Buf) + kHeaderSize);
  59.     
  60.     err = SndDoCommand (channel, &localSndCmd, false);
  61.     if (err != noErr)
  62.         AlertUser(err, iPlaying);
  63.     return;
  64. }
  65.  
  66.  
  67. /***
  68.  * SetUpSounds
  69.  *        SetUpSounds is a routine which takes a buffer handle, sound headers size and
  70.  *        sample rate value and turns it into a snd buffer with the proper header.
  71.  *        It then returns the buffer handle back to the caller.
  72.  ***/
  73. Handle SetUpSounds (Handle Buf, short *HeaderSize, Fixed sampRate)
  74. {
  75.     OSErr        err;
  76.     short        dummy;
  77.     
  78.     Buf = NewHandle(gBuffSize);
  79.     if ((err = MemError()) != noErr || Buf == nil)
  80.         AlertUser(err, iSetupBuffer);
  81.     MoveHHi (Buf);
  82.     if ((err = MemError()) != noErr)
  83.         AlertUser(err, iSetupBuffer);
  84.     HLock (Buf);
  85.     if ((err = MemError()) != noErr)
  86.         AlertUser(err, iSetupBuffer);
  87.     
  88.     /* The call to SetupSndHeader is done twice in order to make sure that the 
  89.     Header size is set correctly.  */
  90.  
  91.     err = SetupSndHeader (Buf, 1, sampRate, 8, 'NONE', 0x3C, 0, HeaderSize);
  92.     if (err != noErr)
  93.         AlertUser(err, iSetupBuffer);
  94.     err = SetupSndHeader (Buf, 1, sampRate, 8, 'NONE', 0x3C, gBuffSize - *HeaderSize, &dummy);
  95.     if (err != noErr)
  96.         AlertUser(err, iSetupBuffer);
  97.         
  98.     return (Buf);
  99. }
  100.  
  101. /***
  102.  * RndRange
  103.  *        Pick a random number from min to max.
  104.  ***/
  105. short RndRange(short min, short max)
  106. {
  107.     unsigned short r = (unsigned short)Random();
  108.     short d = max-min+1;
  109.     return r / (0x10000/d) + min;
  110. }
  111.  
  112.  
  113. /***
  114.  * PickPlayableBuffer
  115.  *        Return the index of a buffer which is ready to be played. It randomly
  116.  *        picks one from the playable buffers, that is, ones which have some
  117.  *        sound in them. If it cant find one, then it returns a value too big.
  118.  ***/
  119. short PickPlayableBuffer(BufInfo *buffers, short max)
  120. {
  121.     short rnd;
  122.     short i;
  123.  
  124.     for(rnd = RndRange(0,max-1), i=0; 
  125.             !buffers[rnd].playable; 
  126.             i++)
  127.         {
  128.         /* try 100 times to find a good buffer before quitting */
  129.         /* oh shuddup, I know its dumb. */
  130.         if (i>100)
  131.             return max+1;
  132.  
  133.         rnd = RndRange(0,max-1);
  134.         }
  135.     return rnd;
  136. }
  137.  
  138.  
  139. /***
  140.  * PickReadableBuffer
  141.  *        Return the index of a buffer which can read some new sounds
  142.  *        First it fills up each buffer, then it randomly picks new ones
  143.  *        once they are all full.
  144.  ***/
  145. short PickReadableBuffer(BufInfo *buffers, short max)
  146. {
  147.     short rnd;
  148.     short i;
  149.  
  150.     for(i=0; i<max; i++)
  151.         {
  152.         if (!buffers[i].playable)
  153.             return i;
  154.         }
  155.  
  156.     return RndRange(0,max-1);
  157. }
  158.  
  159.  
  160. #define Abs(x)        ((x<0)?-(x):x)
  161. #define BlankSpace    0x1000
  162.  
  163. /***
  164.  * TrimBuffer
  165.  *        If the buffer is silent, then return false. Otherwise, reduce the
  166.  *        buffer to just the parts that have sound.
  167.  ***/
  168. long TrimBuffer(Handle buffer, long headerlen)
  169. {
  170.     Boolean result = false;
  171.     long oldBuffSize = GetHandleSize(buffer);
  172.     long oldEnd = 0;
  173.     long oldStart = headerlen;
  174.     long newIndex = 0;
  175.     long copySize = 0;
  176.     long bufByte = 0;
  177.     Boolean firstTime = true;
  178.     Handle tmpbuffer = gExtraBuffer.buffer;
  179.  
  180.     /* copy header into new buffer */
  181.     BlockMove(*buffer, *tmpbuffer, headerlen);
  182.  
  183.     /* determine if the buffer was loud enough */
  184.     /* loud means that a byte in the buffer is far enough away from the */
  185.     /* center to get above the gThreshold */
  186.     for (bufByte=0; bufByte<oldBuffSize-headerlen; bufByte++)
  187.         {
  188.         short delta = 0x80 - (unsigned char)(*buffer)[headerlen + bufByte];
  189.         if (Abs(delta) << 1 > gThreshold)
  190.             {
  191.             /* the first time we hear something, save the previous BlankSpace bytes */
  192.             /* until now. */
  193.             if (firstTime)
  194.                 {
  195.                 /* If we are close to the beginning, copy from the beginning. */
  196.                 /* otherwise, copy blank space until this spot */
  197.                 if (bufByte > BlankSpace)
  198.                     oldStart = bufByte - BlankSpace;
  199.                 else
  200.                     oldStart = 0;
  201.                     
  202.                 /* If we are near the end, copy to the end. */
  203.                 /* otherwise, copy blank space after this spot */
  204.                 oldEnd = bufByte + BlankSpace;
  205.                 if (headerlen + oldEnd > oldBuffSize)
  206.                     oldEnd = oldBuffSize - headerlen;
  207.                 copySize = oldEnd - oldStart;
  208.  
  209.                 BlockMove(&(*buffer)[headerlen+oldStart], &(*tmpbuffer)[headerlen+newIndex], copySize);
  210.                 newIndex += copySize;
  211.                 bufByte = oldEnd;
  212.                 firstTime = false;
  213.                 }
  214.             else
  215.                 {
  216.                 /* After the first time, bufByte > BlankSpace. */
  217.                 oldStart = bufByte - BlankSpace;
  218.                 if (oldStart < oldEnd)
  219.                     oldStart = oldEnd+1;
  220.  
  221.                 oldEnd = bufByte + BlankSpace;
  222.                 if (headerlen + oldEnd > oldBuffSize)
  223.                     oldEnd = oldBuffSize - headerlen;
  224.                 copySize = oldEnd - oldStart;
  225.  
  226.                 BlockMove(&(*buffer)[headerlen+oldStart], &(*tmpbuffer)[headerlen+newIndex], copySize);
  227.                 newIndex += copySize;
  228.                 bufByte = oldEnd;
  229.                 }
  230.             result = true;
  231.             }
  232.         }
  233.     
  234.     if (result)
  235.         {
  236.         BlockMove(*tmpbuffer, *buffer, newIndex+headerlen);
  237.         return newIndex;
  238.         }
  239.     else
  240.         {
  241.         return 0L;
  242.         }
  243. }
  244.  
  245.  
  246.  
  247. #define TestBit(l,b)    ((l>>b)&0x01)
  248.  
  249. /***
  250.  * InitSoundConfusion
  251.  *        Allocate memory and initialize the sound driver
  252.  ***/
  253. void InitSoundConfusion(void)
  254. {
  255.     Level                myLevel;
  256.     OSErr                err;
  257.     long                feature;
  258.     BufInfo                *Buffers = nil;
  259.     short                i;
  260.     short                numBuffers;
  261.     short                meterState;
  262.     SPBPtr                RecordRec = nil;
  263.     Str255                settingStr;
  264.     long                tmplong;
  265.  
  266.     /* use Gestalt to make sure the app will work */
  267.     err = Gestalt(gestaltSoundAttr, &feature);
  268.     if (err == noErr)
  269.         {
  270.         if (!TestBit(feature, gestaltHasSoundInputDevice))
  271.             {
  272.             AlertUser(0, iNoInput);
  273.             ExitToShell();
  274.             }
  275.         else
  276.             {
  277.  
  278.             struct {
  279.                 short ignore;
  280.                 char majSys;
  281.                 char minSys;
  282.                 } sysVersion;
  283.  
  284.             /* does the machine have stereo? */
  285.             inStereo = TestBit(feature, gestaltStereoCapability);
  286.             
  287.             /* can the machine play and record simultaneously? */
  288.             /* prior to system 7.1, we could assume that if the machine */
  289.             /* had stereo, then it has the better Sound Chip and thus */
  290.             /* can play and record at the same time. 7.1 added the */
  291.             /* gestaltPlayAndRecord bit. I dont have 7.1 yet, but I */
  292.             /* will take Jim Reekes word for it. I put it in my */
  293.             /* GestaltEqu.h file as gestaltPlayAndRecord = 6 */
  294.             err = Gestalt(gestaltSystemVersion, (long*)&sysVersion);
  295.             if (err != noErr)
  296.                 {
  297.                 AlertUser(err, iGestaltFailed);
  298.                 ExitToShell();
  299.                 }
  300.             if (((sysVersion.majSys == 7) && (sysVersion.minSys >= 0x10)) || (sysVersion.majSys > 7))
  301.                 gPlayNRecord = TestBit(feature, gestaltPlayAndRecord);
  302.             else
  303.                 gPlayNRecord = inStereo;
  304.                 
  305.             }
  306.         }
  307.     else
  308.         {
  309.         AlertUser(err, iGestaltFailed);
  310.         ExitToShell();
  311.         }
  312.     
  313.     /* the threshold is a setting in the STR# resource */
  314.     GetIndString(settingStr, rSettingStrings, iThreshold);
  315.     StringToNum(settingStr, &tmplong);
  316.     gThreshold = tmplong;
  317.  
  318.     /* the buffer size is also keps as a string */
  319.     GetIndString(settingStr, rSettingStrings, iBufferSize);
  320.     StringToNum(settingStr, &tmplong);
  321.     gBuffSize = tmplong;
  322.     
  323.     /* There was a time when I was thinking of making an INIT, so I was */
  324.     /* going to keep all globals in a handle, but I changed my mind */
  325.     /* some of these can just be normal global variables, but what */
  326.     /* the heck. */
  327.     globs = (SCGlobals*)NewPtr(sizeof(SCGlobals));
  328.     if ((err = MemError()) != noErr || globs == nil)
  329.         {
  330.         AlertUser(err, iMakingGlobals);
  331.         return;
  332.         }
  333.     globs->fullBuffer = true;
  334.     globs->loudEnough = false;
  335.     globs->bufferGettingFilled = 0;
  336.     globs->leftChan = nil;
  337.     globs->rightChan = nil;
  338.     globs->buffers = nil;
  339.     globs->numBuffers = 0;
  340.     globs->RecordRec = nil;
  341.     globs->direction = iPlay;        /* next time through, it records */
  342.     
  343.     /* Open sound input drive (whichever one is selected in the sound cdev) */
  344.     err = SPBOpenDevice (nil, siWritePermission, &globs->SoundRefNum);
  345.     if (err != noErr)
  346.         {
  347.         AlertUser(err, iOpeningDevice);
  348.         return;
  349.         }
  350.  
  351.     /* Get the sample rate information for the snd header */
  352.     err = SPBGetDeviceInfo (globs->SoundRefNum,siSampleRate, (Ptr) &globs->sampleRate);
  353.     if (err != noErr)
  354.         {
  355.         AlertUser(err, iGettingRate);
  356.         return;
  357.         }
  358.     
  359.     /* build the RecordRec pointer and fill in the fields */
  360.     RecordRec = (SPBPtr) NewPtr(sizeof (SPB));
  361.     if ((err = MemError()) != noErr || RecordRec == nil)
  362.         {
  363.         AlertUser(err, iMakingRecordRec);
  364.         return;
  365.         }
  366.     globs->RecordRec = RecordRec;
  367.  
  368.     /* how many buffers can we make? (leave space for an extra buffer and then some memory) */
  369.     numBuffers = ((FreeMem() - kExtraMem) / gBuffSize) - 1;
  370.     if (numBuffers < 1)
  371.         {
  372.         AlertUser(0, iMemory);
  373.         return;
  374.         }
  375.     
  376.     Buffers = (BufInfo*)NewPtr(sizeof(BufInfo)*numBuffers);
  377.     if ((err = MemError()) != noErr || Buffers == nil)
  378.         {
  379.         AlertUser(err, iAllocatingBuffers);
  380.         return;
  381.         }
  382.     globs->buffers = Buffers;
  383.     globs->numBuffers = numBuffers;
  384.         
  385.     
  386.     /* build the snd buffers */
  387.     for (i=0; i<numBuffers; i++)
  388.         {
  389.         Buffers[i].buffer = SetUpSounds(Buffers[i].buffer, &Buffers[i].headerlength, globs->sampleRate);
  390.         Buffers[i].buffSize = gBuffSize - Buffers[i].headerlength;
  391.         Buffers[i].playable = false;
  392.         }
  393.  
  394.     gExtraBuffer.buffer = SetUpSounds(gExtraBuffer.buffer, &gExtraBuffer.headerlength, globs->sampleRate);
  395.  
  396.     RecordRec->inRefNum = globs->SoundRefNum;
  397.     RecordRec->count =  gBuffSize - Buffers[0].headerlength;
  398.     RecordRec->milliseconds = 0;
  399.     RecordRec->bufferLength = gBuffSize - Buffers[0].headerlength;
  400.     RecordRec->bufferPtr = (Ptr) ((*Buffers[0].buffer) + Buffers[0].headerlength);
  401.     RecordRec->completionRoutine = (ProcPtr) &MyRecComp;
  402.     RecordRec->interruptRoutine = nil;
  403.     RecordRec->userLong = (long)globs;
  404.     RecordRec->error = 0;
  405.     RecordRec->unused1 = 0;
  406.     
  407.  
  408. #ifdef IMOVEDTHISINTORESETCHANNELS
  409.  
  410.     /* if the machine has stereo, then open the right and left channels */
  411.     if (inStereo)
  412.         {
  413.         /* open the left channel which I can play from */
  414.         globs->leftChan = nil;
  415.         err = SndNewChannel (&globs->leftChan, sampledSynth, initChanLeft, nil);
  416.         if (err != noErr)
  417.             {
  418.             AlertUser(err, iMakingLeft);
  419.             return;
  420.             }
  421.         
  422.         /* open the right channel which I can play from */
  423.         globs->rightChan = nil;
  424.         err = SndNewChannel (&globs->rightChan, sampledSynth, initChanRight, nil);
  425.         if (err != noErr)
  426.             {
  427.             AlertUser(err, iMakingRight);
  428.             return;
  429.             }
  430.         }
  431.     else
  432.         {
  433.         /* open a mono channel and keep in the 'left' variable */
  434.         globs->leftChan = nil;
  435.         err = SndNewChannel (&globs->leftChan, sampledSynth, initMono, nil);
  436.         if (err != noErr)
  437.             {
  438.             AlertUser(err, iMakingMono);
  439.             return;
  440.             }
  441.         }
  442. #endif
  443.  
  444.     globs->firstTime = true;
  445.     
  446. //    ResetChannels();
  447.     
  448. }
  449.  
  450.  
  451. /***
  452.  * ResetChannels
  453.  *
  454.  *        Close (if not already) and then open the sound channel(s)
  455.  ***/
  456. void ResetChannels()
  457. {
  458.     SndCommand        mycmd;
  459.     OSErr            err;
  460.     static Boolean channelsExist = false;
  461.     
  462.     if (channelsExist)
  463.         {
  464.         /* stop playing sounds now */
  465.         mycmd.cmd = quietCmd;
  466.         mycmd.param1 = 0;
  467.         mycmd.param2 = 0;
  468.         if (globs->leftChan)
  469.             {
  470.             /* tell the left channel to shut up */
  471.             err = SndDoImmediate (globs->leftChan, &mycmd);
  472.             if (err != noErr)
  473.                 {
  474.                 AlertUser(err, iClosing);
  475.                 return;
  476.                 }
  477.                 
  478.             /* kill the left channel */
  479.             err = SndDisposeChannel (globs->leftChan,false);
  480.             if (err != noErr)
  481.                 {
  482.                 AlertUser(err, iClosing);
  483.                 return;
  484.                 }
  485.             }
  486.         if (inStereo && globs->rightChan)
  487.             {
  488.             /* tell the right channel to shut up */
  489.             err = SndDoImmediate (globs->rightChan, &mycmd);
  490.             if (err != noErr)
  491.                 {
  492.                 AlertUser(err, iClosing);
  493.                 return;
  494.                 }
  495.     
  496.             /* kill the right channel */
  497.             err = SndDisposeChannel (globs->rightChan,false);
  498.             if (err != noErr)
  499.                 {
  500.                 AlertUser(err, iClosing);
  501.                 return;
  502.                 }
  503.             }
  504.         }
  505.  
  506.     /* if the machine has stereo, then open the right and left channels */
  507.     if (inStereo)
  508.         {
  509.         /* open the left channel which I can play from */
  510.         globs->leftChan = nil;
  511.         err = SndNewChannel (&globs->leftChan, sampledSynth, initChanLeft, nil);
  512.         if (err != noErr)
  513.             {
  514.             AlertUser(err, iMakingLeft);
  515.             return;
  516.             }
  517.         
  518.         /* open the right channel which I can play from */
  519.         globs->rightChan = nil;
  520.         err = SndNewChannel (&globs->rightChan, sampledSynth, initChanRight, nil);
  521.         if (err != noErr)
  522.             {
  523.             AlertUser(err, iMakingRight);
  524.             return;
  525.             }
  526.         }
  527.     else
  528.         {
  529.         /* open a mono channel and keep in the 'left' variable */
  530.         globs->leftChan = nil;
  531.         err = SndNewChannel (&globs->leftChan, sampledSynth, initMono, nil);
  532.         if (err != noErr)
  533.             {
  534.             AlertUser(err, iMakingMono);
  535.             return;
  536.             }
  537.         }
  538.  
  539.     channelsExist = true;
  540. }
  541.  
  542.  
  543. /***
  544.  * ConfuseSound
  545.  *        This is called during idle time from the event loop.
  546.  *        It starts recording from a buffer and playing from another one.
  547.  ***/
  548. void ConfuseSound(void)
  549. {
  550.     short            dummy;
  551.     OSErr            err;
  552.     BufInfo            *Buffers;
  553.     short            i;
  554.     SndCommand        mycmd;
  555.     long            bufByte;
  556.     short            bufNum;
  557.     Boolean            stillWorking = false;
  558.     Boolean            stillPlaying = false;
  559.     Boolean            stillRecording = false;
  560.     SCStatus        chanStatL;
  561.     SCStatus        chanStatR;
  562.     static    unsigned long    lastResetTime = 0L;
  563.     unsigned long    currTime;
  564.     
  565.     GetDateTime(&currTime);
  566.     
  567.     if (currTime - lastResetTime > kResetInterval)
  568.         {
  569.         ResetChannels();
  570.         lastResetTime = currTime;
  571.         }
  572.     
  573.     /* easier access to the buffers */
  574.     Buffers = globs->buffers;
  575.  
  576.     /* some stuff to prevent us from playing and recording simultaneously */
  577.     /* on a machine that is incapable of it. */
  578.     if (globs->firstTime)
  579.         {
  580.         stillPlaying = false;
  581.         stillRecording = false;
  582.         }
  583.     else 
  584.         {
  585.         if (globs->direction == iPlay || gPlayNRecord)
  586.             {
  587.             err = SndChannelStatus(globs->leftChan, sizeof(SCStatus), &chanStatL);
  588.             if (err != noErr)
  589.                 AlertUser(err, iPlaying);
  590.             stillPlaying = chanStatL.scChannelBusy;
  591.  
  592.             if (inStereo && !stillPlaying)
  593.                 {
  594.                 err = SndChannelStatus(globs->rightChan, sizeof(SCStatus), &chanStatR);
  595.                 if (err != noErr)
  596.                     AlertUser(err, iPlaying);
  597.                 stillPlaying = chanStatR.scChannelBusy;
  598.                 }
  599.                 
  600.             }
  601.         if (globs->direction == iRecord || gPlayNRecord)
  602.             {
  603.             stillRecording = !globs->fullBuffer;
  604.             }
  605.         }
  606.     
  607.     stillWorking = stillPlaying || stillRecording;
  608.     
  609.     /* if we cant play and record, then exit if we are in the middle of */
  610.     /* playing or recording. we can pass through as soon as the process is done */
  611.     if ((!gPlayNRecord && stillWorking) || (stillPlaying && stillRecording))
  612.         return;
  613.  
  614.  
  615.     /* if this is the first time through, then prepare to record into a buffer */
  616.     /* if a buffer recording has finished (ie, the buffer is full), then prepare */
  617.     /* to record into another buffer */
  618.     if (!stillRecording)
  619.         {
  620.         globs->fullBuffer = false;
  621.     
  622.         if (!globs->firstTime && (gPlayNRecord || globs->direction == iRecord))
  623.             {
  624.             long newSize;
  625.             bufNum = globs->bufferGettingFilled;
  626.             
  627.             /* trim the buffer by removing silent (quiet) sections */
  628.             newSize = TrimBuffer(Buffers[bufNum].buffer, Buffers[bufNum].headerlength);
  629.             Buffers[bufNum].playable = globs->loudEnough = (newSize > 0);
  630.             Buffers[bufNum].buffSize = newSize;
  631.     
  632.             /* if the buffer was loud enough, then prepare to record the next readable buffer */
  633.             if (globs->loudEnough)
  634.                 {
  635.                 short nextbuf = PickReadableBuffer(Buffers, globs->numBuffers);
  636.                 globs->bufferGettingFilled = nextbuf;
  637.                 globs->loudEnough = false;
  638.                 Buffers[nextbuf].playable = false;
  639.                 HUnlock(Buffers[nextbuf].buffer);
  640.                 SetHandleSize(Buffers[nextbuf].buffer, gBuffSize);
  641.                 MoveHHi(Buffers[nextbuf].buffer);
  642.                 HLock(Buffers[nextbuf].buffer);
  643.                 globs->RecordRec->bufferPtr = (*Buffers[nextbuf].buffer) + Buffers[nextbuf].headerlength;
  644.                 }
  645.             }
  646.                 
  647.         globs->firstTime = false;
  648.  
  649.         if (gPlayNRecord)
  650.             {
  651.             /* start recording into the buffer asynchronously */
  652.             err = SPBRecord (globs->RecordRec, true); // start recording
  653.             if (err != noErr)
  654.                 AlertUser(err, iRecording);
  655.             }
  656.         }
  657.     
  658.     if (gPlayNRecord && !stillPlaying)
  659.         {
  660.         /* pick a buffer to play from */    
  661.         i = PickPlayableBuffer(Buffers, globs->numBuffers);
  662.         if (i<=globs->numBuffers)
  663.             {
  664.             long bsize = Buffers[i].buffSize;
  665.             err = SetupSndHeader (Buffers[i].buffer, 1, globs->sampleRate, 8, 'NONE', 0x3C, bsize, &dummy);
  666.             if (err != noErr)
  667.                 AlertUser(err, iPlaying);
  668.             /* play it asynchronously */
  669.             BufPlay(Buffers[i].buffer, 
  670.                     inStereo ? (RndRange(0,1) ? globs->leftChan : globs->rightChan) : globs->leftChan);
  671.             }
  672.         }
  673.     
  674.     
  675.     /* if we cant play and record simultaneously, then do t`he one that */
  676.     /* we werent doing last. in other words, take turns playing and recording */
  677.     if (!gPlayNRecord)
  678.         {
  679.         if (globs->direction == iPlay)
  680.             {
  681.             globs->fullBuffer = false;
  682.             /* start recording into the buffer asynchronously */
  683.             err = SPBRecord (globs->RecordRec, true); // start recording
  684.             if (err != noErr)
  685.                 AlertUser(err, iRecording);
  686.             globs->direction = iRecord;
  687.             }
  688.         else /* if (globs->direction == iRecord) */
  689.             {
  690.             /* pick a buffer to play from */    
  691.             i = PickPlayableBuffer(Buffers, globs->numBuffers);
  692.             if (i<=globs->numBuffers)
  693.                 {
  694.                 long bsize = Buffers[i].buffSize;
  695.                 err = SetupSndHeader (Buffers[i].buffer, 1, globs->sampleRate, 8, 'NONE', 0x3C, bsize, &dummy);
  696.                 if (err != noErr)
  697.                     AlertUser(err, iPlaying);
  698.                 /* play it asynchronously */
  699.                 BufPlay(Buffers[i].buffer, 
  700.                         inStereo ? (RndRange(0,1) ? globs->leftChan : globs->rightChan) : globs->leftChan);
  701.                 }
  702.             globs->direction = iPlay;
  703.             globs->fullBuffer = true;
  704.             }
  705.         }
  706. }
  707.  
  708.  
  709. /***
  710.  * StopConfusion
  711.  *        Deallocate memory and close stuff.
  712.  ***/
  713. void StopConfusion(void)
  714. {
  715.     OSErr            err;
  716.     SndCommand        mycmd;
  717.     short            i;
  718.  
  719.     if (!globs)
  720.         return;
  721.  
  722.     /* stop playing sounds now */
  723.     mycmd.cmd = quietCmd;
  724.     mycmd.param1 = 0;
  725.     mycmd.param2 = 0;
  726.     if (globs->leftChan)
  727.         {
  728.         /* tell the left channel to shut up */
  729.         err = SndDoImmediate (globs->leftChan, &mycmd);
  730.         if (err != noErr)
  731.             AlertUser(err, iClosing);
  732.             
  733.         /* kill the left channel */
  734.         err = SndDisposeChannel (globs->leftChan,false);
  735.         if (err != noErr)
  736.             AlertUser(err, iClosing);
  737.         }
  738.     if (inStereo && globs->rightChan)
  739.         {
  740.         /* tell the right channel to shut up */
  741.         err = SndDoImmediate (globs->rightChan, &mycmd);
  742.         if (err != noErr)
  743.             AlertUser(err, iClosing);
  744.  
  745.         /* kill the right channel */
  746.         err = SndDisposeChannel (globs->rightChan,false);
  747.         if (err != noErr)
  748.             AlertUser(err, iClosing);
  749.         }
  750.  
  751.     if (globs->SoundRefNum != 0)
  752.         {
  753.         /* close the input device */
  754.         SPBCloseDevice (globs->SoundRefNum);
  755.         }
  756.     
  757.     if (globs->buffers)
  758.         {
  759.         /* kill the snd buffers */
  760.         for (i=0; i<globs->numBuffers; i++)
  761.             {
  762.             if (globs->buffers[i].buffer)
  763.                 {
  764.                 HUnlock(globs->buffers[i].buffer);
  765.                 DisposeHandle(globs->buffers[i].buffer);
  766.                 }
  767.             }
  768.         }
  769.  
  770.     if (gExtraBuffer.buffer)
  771.         {
  772.         HUnlock(gExtraBuffer.buffer);
  773.         DisposeHandle(gExtraBuffer.buffer);
  774.         }
  775.  
  776.     /* kill the buffers */
  777.     DisposePtr ((Ptr) globs->buffers);
  778.     DisposePtr ((Ptr) globs->RecordRec);
  779.     DisposePtr ((Ptr) globs);
  780. }
  781.  
  782.  
  783. /**********************************/
  784.  
  785. void DoAbout()
  786. {
  787.     Str31 numBufsStr;
  788.     Str31 numFilledStr;
  789.     short numFilled = 0;
  790.     short i;
  791.     short itemHit;
  792.     DialogPtr dlg;
  793.     
  794.     for (i=0; i<globs->numBuffers; i++)
  795.         {
  796.         if (globs->buffers[i].playable)
  797.             numFilled++;
  798.         }
  799.     NumToString((long)globs->numBuffers, numBufsStr);
  800.     NumToString((long)numFilled, numFilledStr);
  801.     ParamText(numBufsStr, numFilledStr, "", "");
  802.  
  803.     dlg = GetNewDialog(rAboutAlert, NULL, (WindowPtr)-1L);
  804.     ModalDialog(NULL, &itemHit);
  805.     DisposDialog(dlg);
  806. }
  807.  
  808.  
  809. /***
  810.  * MyRecComp
  811.  *
  812.  * This is the Completion Routine which is called every time the buffer,
  813.  * which is being recorded into, is full.
  814.  ***/
  815. pascal void MyRecComp (SPBPtr inParamPtr)
  816. {
  817.     SCGlobals *glob;
  818.     
  819.     glob = (SCGlobals*)inParamPtr->userLong;
  820.     glob->fullBuffer = true;
  821.  
  822.     if (inParamPtr->error != noErr)
  823.         {
  824.         AlertUser(inParamPtr->error, iPlaying);
  825.         }
  826.  
  827.     return;
  828. }
  829.